home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
MacFormat 1995 June
/
MacFormat 25.iso
/
Shareware City
/
Developers
/
Tools Plus 2.5.3 Evaluation Kit
/
Tools Plus 2.5.3
/
Tools Plus 2.5.3 for Pascal
/
ToolsPlus.p
< prev
Encoding:
Amiga
Atari
Commodore
DOS
FM Towns/JPY
Macintosh
Macintosh JP
NeXTSTEP
RISC OS/Acorn
Shift JIS
UTF-8
Wrap
Text File
|
1994-12-12
|
59.9 KB
|
1,156 lines
|
[
TEXT/PJMM
]
{ Tools Plus (Version 2.5.3) Pascal interface }
{ Copyright (C) 1989-95 Water’s Edge Software }
{ This unit is the interface between Pascal applications and Tools Plus. It must be used by any program or unit }
{ that makes reference to any part of Tools Plus. }
{ }
{ All TYPEs, VARiables, and CONSTants required by Tools Plus are included. }
{ }
{ You must include the entire set of Tools Plus libraries and related files in your project: }
{ ToolsPlus.Lib1 }
{ ToolsPlus.Lib2 }
{ ToolsPlus.Lib3 }
{ ToolsPlus.p }
unit ToolsPlus;
interface
const
UseColor = true; {INITIALIZATION: Use color if available }
IgnoreColor = false; { Don't use color }
doNothing = 0; {POLLING: no event }
doChgWindow = 1; { user clicked in an inactive window }
doRefresh = 2; { a window has to be refreshed }
doGoAway = 3; { the close box was clicked }
doButton = 4; { button was clicked }
doMenu = 5; { menu was selected }
doKeyDown = 6; { a keyboard key was pressed }
doAutoKey = 7; { a keyboard key is auto-repeating }
doKeyUp = 8; { a keyboard key was released }
doClickField = 9; { mouse clicked in inactive field }
doScrollBar = 10; { mouse clicked in a scroll bar }
doListBox = 11; { some sort of List Box activity }
doClick = 12; { mouse click/drag }
doPopUpMenu = 13; { pop-up menu was selected }
doPictButton = 14; { picture button activity }
doClickControl = 101; { mouse clicked in a custom control }
doManualEvent = 102; { manually processed events }
doMoveWindow = 103; { a window was moved by user }
doGrowWindow = 104; { a window was re-sized by the user }
doClickDesk = 105; { mouse clicked in the desk top }
doZoomWindow = 106; { zoom box was clicked by user }
doSuspend = 107; { appl. suspended (in background) }
doResume = 108; { appl. resumed (now active appl.) }
doChgInField = 109; { editing field contents was changed }
doPreRefresh = 110; { refresh window before T+ objects }
inClick1 = 1; {CLICK: mouse single-click completed }
inClick2 = 2; { mouse double-click completed }
inClick3 = 3; { mouse triple-click completed }
inClick1Drag = -1; { mouse single-click, still dragging }
inClick2Drag = -2; { mouse double-click, still dragging }
inClick3Drag = -3; { mouse triple-click, still dragging }
EnterKey = chr($03); {KEYS: Key characters (ASCII) for common }
BackSpaceKey = chr($08); { non apha-numeric keys. }
TabKey = chr($09); { In some cases, several keys }
ReturnKey = chr($0D); { produce the same ASCII }
EscClearKey = chr($1B); { ($1B) character. They can be }
LeftArrowKey = chr($1C); { differentiated by using the key }
RightArrowKey = chr($1D); { code, as indicated below. }
UpArrowKey = chr($1E); { Some keys are available only }
DownArrowKey = chr($1F); { on an extended keyboard. }
HelpKey = chr($05); { }
HomeKey = chr($01); { }
DeleteFwdKey = chr($7F); { }
EndKey = chr($04); { }
PageUpKey = chr($0B); { }
PageDownKey = chr($0C); { }
FKey = chr($10); { ($10) Function keys F1 to F15 }
EscKeyCode = $35; { ($1B) KEY CODES used to differentiate }
ClearKeyCode = $47; { ($1B) between keys which produce }
F1KeyCode = $7A; { the same key characters. }
F2KeyCode = $78; { }
F3KeyCode = $63; { }
F4KeyCode = $76; { }
F5KeyCode = $60; { }
F6KeyCode = $61; { }
F7KeyCode = $62; { }
F8KeyCode = $64; { }
F9KeyCode = $65; { }
F10KeyCode = $6D; { }
F11KeyCode = $67; { }
F12KeyCode = $6F; { }
F13KeyCode = $69; { }
F14KeyCode = $6B; { }
F15KeyCode = $71; { }
mDividingLine = '-'; {MENUS: Dividing line }
AppleChar = chr($14); {MENU CHARS: Apple character }
CheckChar = chr($12); { Check Mark character }
DiamondChar = chr($13); { Diamond character }
DotChar = chr($A5); { Dot (or bullet) character }
NoChar = chr($00); { no character }
{PICTURE BUTTONS: }
picbutInstantEvent = $80000000; { Report event on mouse-down }
picbutTrackWithHilite = $40000000; { Track using hiliting, like a radio button }
picbutLockSelected = $20000000; { Lock if selected (mouse can't deselect) }
picbutSwitchSelected = $10000000; { Switch 'selected' state if clicked }
picbutRepeatEvents = $08000000; { Repeat event when button is held down }
picbutAutoValueChg = $04000000; { Automatically change button's value }
picbutScaleLinear = $00000000; { Rate of automatic value change… }
picbutScaleSlowAccel = $01000000; { Linear, Slow Acceleration, }
picbutScaleMedAccel = $02000000; { Medium Acceleration, and }
picbutScaleFastAccel = $03000000; { Fast Acceleration. }
picbutLinear = 0; { Linear (use in structure) }
picbutSlowAccel = 1; { Slow (use in structure) }
picbutMedAccel = 2; { Medium (use in structure) }
picbutFastAccel = 3; { Fast (use in structure) }
picbutValueWrap = $00800000; { Button's range of values 'wrap' around }
picbutLeftRightSplit = $00400000; { Left side reduces value, right increases }
picbutTopBottomSplit = $00200000; { Top increases value, bottom reduces }
picbutMultiStage = $00100000; { Button has multiple stages }
picbutBigSICN3D = $00080000; { Create a larger SICN 3D button }
picbutUsePICTS = $00040000; { Use PICTs instead of icons }
picbutGray4use8 = $00020000; { Use 8-bit color pict on 4-bit gray monitor }
{ Selection Effects… }
picbutSelectDarken = $00010000; { Darken image }
picbutSelectDarkenSICN3D = $00008000; { Darken (and push in) a 3D SICN icon }
picbutSelectLightenSICN3D = $00004000; { Lighten (and push in) a 3D SICN icon }
picbutSelectPushedSICN3D = $00002000; { Same color (and push in) a 3D SICN icon}
picbutSelectAltImage = $00000400; { Use an alternate image }
{ Disabling Effects… }
picbutDimUsingBlackLite = $00000100; { Overlay Black color using Lt Gray pat. }
picbutDimUsingWhiteLite = $00000080; { Overlay White color using Lt Gray pat. }
picbutDimUsingWhite = $00000040; { Overlay White color using Gray pat. }
picbutDimLeaveBorder = $00000008; { Leave border when applying effect }
picbutDimAltImage = $00000004; { Use an alternate image }
picbutDimNoChange = $00000002; { Button looks the same when disabled }
{POP-UP MENUS: }
popupNeverDimOutline = $0100; { Never dim the control's outline? }
popupNeverDimSelection = $0080; { Never dim the selected item's text? }
popupNeverDimTitle = $0040; { Never dim the title? }
popupNoArrow = $0020; { Is the "down arrow" hidden? }
popupMultiSelect = $0010; { Allow multiple items to be selected? }
popupUseWFont = $0008; { Use the window's font for the menu? }
popupIconTitle = $0004; { Draw icon in the control's title? }
popupFixedTitle = $0002; { Is a fixed title displayed in the control? }
popupDefaultType = $0000; { Default menu (sys font, 1 item, no icon) }
arrowCursor = 0; {CURSORS: "arrow" cursor }
GoAway = true; {WINDOWS: no "close box" }
NoGoAway = false; { window has a "close box" }
Modal = true; { window is modal }
NotModal = false; { window is modeless }
ZoomBox = 8; { zoom box (add to procID) }
wCenter = $00010000; { auto-centering (add to procID) }
wTile = $00020000; { auto-tiling (add to procID) }
wPalette = $80000000; { palette behavior (add to procID) }
ordPaletteProc = 32000; { window that looks like Palette }
paletteProc = 32000 + wPalette; { T+’s Floating Palette window }
altPaletteProc = 32002 + wPalette; { T+’s palette with drag bar on left }
wNoKind = 0; { Kinds of Windows: Not open }
wToolBarKind = 1; { Tool Bar }
wFloatingKind = 2; { Floating Palette }
wStandardKind = 3; { Standard Window }
wAnimateMove = $01; { Moving Windows: Animate w/Zoom Lines }
wOffsetForToolBar = $02; { Offset co-ords for TB }
wShow = true; { Hiding Windows: Display (unhide) }
wHide = false; { Hide window }
tbShiftWindows = $01; {TOOL BAR: Shift windows when TB opens }
tbOffsetNewWindows = $02; { Offset new windows as they }
{ are opened (if TB is open). }
DefaultButton = 4; {BUTTONS: “default” for the window }
selected = true; { button is selected (i.e. checked)}
notSelected = false; { button is not selected }
scrlLeftEdge = -1; {SCROLL BARS: left edge of document }
scrlTopEdge = -1; { top edge of document }
scrlRightEdge = 32767; { right edge of document }
scrlBottomEdge = 32767; { bottom edge of document }
{BUTTONS, MENUS, SCROLL BARS & ICONS: }
enabled = true; { object is enabled }
disabled = false; { object is disabled }
teBoxNoCR = 0; {EDIT FIELDS: box around field, no CR allowed }
teBoxCR = 1; { box around field, CR allowed }
teNoBoxNoCR = 2; { no box, no CR allowed }
teNoBoxCR = 3; { no box, CR allowed }
teSelectAll = 0; {EDIT FIELD SELECTION: all of text }
teSelectStart = 1; { beginning of text }
teSelectEnd = 2; { end of text }
teReplace = true; {PASTE INTO FIELD: replace field contents }
teInsert = false; { insert text into field }
OkAltBut = 1; {ALERTS: OK (Buttons refs) }
CanAltBut = 2; { Cancel }
YesAltBut = 3; { Yes }
NoAltBut = 4; { No }
ContAltBut = 5; { Continue }
SkipAltBut = 6; { Skip }
QuitAltBut = 7; { Quit }
NoButtonAlert = 0; { No buttons (Alert Defs) }
OkAlert = 11100; { OK (default) }
CanAlert = 11200; { Cancel (default) }
OkCanAlert = 22210; { OK (default) + Cancel }
CanOkAlert = 21210; { OK + Cancel (default) }
YesNoAlert = 22430; { Yes (default) + No }
NoYesAlert = 21430; { Yes + No (default) }
YesNoCanAlert = 33243; { Yes (default) + No + Cancel }
NoYesCanAlert = 32243; { Yes + No (default) + Cancel }
nmSysBeep = -1; {NOTIFICATION: Use System Error sound }
nmSilentNote = 0; { Silent notification }
nmDefaultMsg = ' '; { Use default message }
nmNoMsg = ''; { Don't display an alert }
nmResetWhenDone = true; { Reset to defaults after used}
nmKeepSettings = false; { Keep settings after used }
NoIcon = -32768; {ICONS: No icon used }
{ Disabled icons' default appearance… }
DfltIconDimBlackLtPat = $01; { Overlay Black color w/ Lt Gray pat. }
DfltIconDimWhiteLtPat = $02; { Overlay White color w/ Lt Gray pat. }
DfltIconDimWhitePat = $04; { Overlay White color w/ Gray pat. }
DfltIconLeaveBorder = $20; { Leave border when selected or disabled }
DfltIconUpdateNow = $8000; { Update all windows with changes }
on = true; {MISCELLANEOUS: }
off = false; { }
maxNullTime = $7FFFFFFF; { Infinite time between doNothing evts }
ZoomAcross = 0; {ZOOM LINES: transitional }
ZoomIn = -1; { zoom inward (further away) }
ZoomOut = 1; { zoom outward (nearer) }
none = 0; {used primarily for polling }
type
{ - - - - - - - - - - These record "types" are used for information transfer between - - - - - - - - - - - }
{ your application and Tools Plus libraries. }
{= Polling record's "event modifiers" info}
TPModifiersRec = packed record {This variable record contains an event's }
case integer of { "modifiers" in 2 formats… }
0: ( { • Macintosh Event: }
Num: integer { integer (bit operations required) }
); { }
1: ( { • Modifier integer parsed into components: }
bit15, bit14, bit13: boolean; { (reserved bits) }
ControlKey: boolean; { Control key was down at event (=1) }
OptionKey: boolean; { Option key was down at event (=1) }
CapsLock: boolean; { Caps Lock was down at event (=1) }
ShiftKey: boolean; { Shift key was down at event (=1) }
CmdKey: boolean; { Command key was down at event (=1) }
MouseUp: boolean; { Mouse button was UP at event (=1) }
bit6, bit5, bit4, bit3, bit2, bit1, bit0: boolean { (reserved bits) }
); { }
end;
{= Polling record's "button" info}
TPPollButtonRec = record
Num: integer; {Button number }
DoubleClick: boolean {Did a double-click occur? }
end;
{= Polling record's "scroll bar" info}
TPPollScrollBarRec = record
Num: integer; {Scroll bar number }
Part: integer {Scroll bar's part }
end;
{= Polling record's "list box" info}
TPPollListBoxRec = record
Num: integer; {List box number }
DoubleClick: boolean {Did a double-click occur? }
end;
{= Polling record's "menu" info}
TPPollMenuRec = record
Num: integer; {Menu number }
Item: integer {Menu item number }
end;
{= Polling record's "key-stroke" info}
TPPollKeyRec = packed record
Code: integer; {Logical key number of the typed key }
Chr: char; {ASCII character generated by typed key }
Unused: byte { (reserved byte) }
end;
{= Polling record's "mouse location and time" info for mouse-down and mouse-up events}
TPPollMousePointRec = record
Where: point; {Event location in local co-ordinates }
When: longint; {Event time in clock ticks from boot (1/60 sec) }
Modifiers: TPModifiersRec {Event modifiers }
end;
{= Polling record's "mouse click/drag" info}
TPPollMouseRec = record
What: integer; {What type of mouse event? (click or drag) }
Down: array[1..3] of TPPollMousePointRec; {Where & when did the mouse-down occur }
Up: array[1..3] of TPPollMousePointRec; {Where & when did the mouse-up occur }
Where: point {Current mouse location in local co-ordinates }
end;
{= POLLING record for Tools Plus}
TPPollPointer = ^TPPollRecord; {Pointer to a Polling record }
TPPollRecord = record {Tools Plus Polling record… }
What: integer; {What type of event has occurred? }
Window: integer; {Window number of the event }
Button: TPPollButtonRec; {Button number/double-click status }
ScrollBar: TPPollScrollBarRec; {Scroll bar number/scroll bar part }
Field: integer; {Field number of event }
ListBox: TPPollListBoxRec; {List box number/double-click status }
Menu: TPPollMenuRec; {Menu number/menu item of an event }
Key: TPPollKeyRec; {Logical key number & character of typed key }
Mouse: TPPollMouseRec; {Click/drag info: [1..3] where & when }
Modifiers: TPModifiersRec; {Modifier flags }
Event: EventRecord {Macintosh Toolbox Event (raw) }
end;
{= WINDOW status information}
TPWindowStatus = record {Window status record… }
Kind: integer; { • Window kind: Tool Bar, Palette, or Standard }
Open: boolean; { • Is the window open? }
Visible: boolean; { • Is this window visible (not hidden)? }
Active: boolean; { • Is this window active? }
Front: boolean; { • Is this the frontmost Tools Plus window? }
Current: boolean; { • Is this the current window? }
WorkWindow: boolean; { • Is this the work window? }
EditFieldWindow: boolean; { • Does this window have the app's active field? }
ActiveField: integer; { • Window's active field number }
StrucRect: rect; { • Structure rect (global). Incl border & title bar }
ContRect: rect; { • Content rect (global). Working area only. }
end;
{= Color Pen information}
ColorPenState = record {Color equivalent for a 'PenState' record. This }
PenState: PenState; { record also stores additional values for the }
ForegroundColor: RGBColor; { window's foreground and background }
BackgroundColor: RGBColor { colors. }
end;
{= Picture Button Appearance & Behavior Specification (or you can use constants instead) }
TPPictButtonSpec = packed record {Picture Button's appearance and behavior }
{ specifications in 2 formats… }
case integer of { }
0: ( { • Parsed into components: }
InstantEvent: boolean; { Report event on mouse-down }
TrackWithHilite: boolean; { Track using hiliting, like a radio button }
LockSelected: boolean; { Lock if selected (mouse can't deselect) }
SwitchSelected: boolean; { Switch 'selected' state if clicked }
RepeatEvents: boolean; { Repeat event when button is held down }
AutoValueChg: boolean; { Automatically change button's value }
AutoValueScaling: 0..3; { Rate of change for button's value }
ValueWrap: boolean; { Button's range of values 'wrap' around }
LeftRightSplit: boolean; { Left side reduces value, right increases }
TopBottomSplit: boolean; { Top increases value, bottom reduces }
MultiStage: boolean; { Button has multiple stages }
BigSICN3D: boolean; { Create a larger SICN 3D button }
UsePICTS: boolean; { Use PICTs instead of icons }
Gray4use8: boolean; { Use 8-bit color pict on 4-bit gray monitor }
{ Selection Effects… }
SelectDarken: boolean; { Darken image }
SelectDarkenSICN3D: boolean; { Darken (and push in) a 3D SICN icon }
SelectLightenSICN3D: boolean; { Lighten (and push in) a 3D SICN icon }
SelectPushedSICN3D: boolean; { Same color (and push in) a 3D SICN icon}
bit19, bit20: boolean; { (reserved bits) }
SelectAltImage: boolean; { Use an alternate image }
bit22: boolean; { (reserved bit) }
{ Disabling Effects… }
DimUsingBlackLite: boolean; { Overlay Black color using Lt Gray pat. }
DimUsingWhiteLite: boolean; { Overlay White color using Lt Gray pat. }
DimUsingWhite: boolean; { Overlay White color using Gray pat. }
bit26, bit27: boolean; { (reserved bits) }
DimLeaveBorder: boolean; { Leave border when applying effect }
DimAltImage: boolean; { Use an alternate image }
DimNoChange: boolean; { Button looks the same when disabled }
bit31: boolean; { (reserved bit) }
); { }
1: ( { • Longint equivalent: }
Num: longint; { Specification longint }
); { }
end;
{= Pop-Up Menu Appearance & Behavior Specification (or you can use constants instead) }
TPPopUpMenuSpec = packed record {Pop-Up Menu's appearance and behavior }
{ specifications in 2 formats… }
case integer of { }
0: ( { • Parsed into components: }
bit15, bit14, bit13, bit12: boolean; { (reserved bits) }
bit11, bit10, bit9: boolean; { (reserved bits) }
NeverDimOutline: boolean; { Never dim the control's outline? }
NeverDimSelectedItem: boolean; { Never dim the selected item's text? }
NeverDimTitle: boolean; { Never dim the title? }
NoArrow: boolean; { Is the "down arrow" hidden? }
MultipleSelections: boolean; { Allow multiple items to be selected? }
useWFont: boolean; { Display using window's font? }
IconInTitle: boolean; { Draw icon in the control's title? }
FixedTitle: boolean; { Is a fixed title displayed in the control? }
bit0: boolean; { (reserved bit) }
); { }
1: ( { • Integer equivalent: }
Num: integer; { Specification integer }
); { }
end; { }
{==================================== I N I T I A L I Z A T I O N ==================================== }
{Initialize Tools Plus}
function InitToolsPlus (MoreHandles: integer; {Number of MoreMasters initializing cycles }
MaxWindows: integer; {Maximum number of windows required }
UseColorFlag: boolean {Should Color QuickDraw be used if available? }
): Boolean; {Was initialization successful? }
{======================================= W I N D O W S ======================================== }
{Open a window and make it current}
procedure WindowOpen (Window: integer; {Window number }
left, top, right, bottom: integer; {Window's co-ordinates (global) }
Title: string; {Window's title (if applicable) }
procID: longint; {Window definition ID }
goAwayFlag, modalFlag: Boolean); {Include Close Box? Is window modal? }
{Open a window and make it current (co-ordinates specified as a 'rect') }
procedure WindowOpenRect (Window: integer; {Window number }
Bounds: rect; {Window's co-ordinates (global) }
Title: string; {Window's title (if applicable) }
procID: longint; {Window definition ID }
goAwayFlag, modalFlag: Boolean); {Include Close Box? Is window modal? }
{Open the tool bar and make it current}
procedure ToolBarOpen (Window: integer; {Window number }
Height: integer; {Tool bar height }
procID: integer); {Appearance/behavior specifications }
{Close a window}
procedure WindowClose (Window: integer); {Window number }
{Change a window's size}
procedure WindowSize (Window: integer; {Window number }
Width, Height: integer; {Window's new width and height }
Update: boolean); {Force doRefresh event for newly exposed rgn? }
{Move a window to the specified co-ordinates}
procedure WindowMove (Window: integer; {Window number }
hGlobal: integer; {Horizontal co-ordinates (global) }
vGlobal: integer; {Vertical co-ordinates (global) }
procID: integer); {Behavior specification }
{Hide or show a window}
procedure WindowDisplay (Window: integer; {Window number }
Show: boolean); {Should the window be shown? }
{Make a specified window the "active" and "current" window}
procedure ActivateWindow (Window: integer); {Window number }
{Set a window's title}
procedure WindowTitle (Window: integer; {Window number }
Title: string); {Window's title (if applicable) }
{Set the current window's "growing" limits (i.e. maximum/minimum size) }
procedure SetWindowSizeLimits (minHoriz, minVert, maxHoriz, MaxVert: integer);{Window's size limits in pixels}
{Set the current window's standard co-ordinates and user co-ordinates for "zooming"}
procedure SetWindowZoom (userRect, stdRect: rect); {User & standard co-ordinates (global) }
{Get the current window's user co-ordinates & standard co-ordinates for "zooming"}
procedure GetWindowZoom (var userRect, stdRect: Rect); {User & standard co-ordinates (global) }
{Make a specified window "current", but do not activate it}
procedure CurrentWindow (Window: integer); {Window number }
{Make the "active" window "current"}
procedure CurrentWindowReset;
{Get a window's status}
procedure WindowStatus (Window: integer; {Window number }
var Status: TPWindowStatus); {Window's status record }
{Get the active window number (last used window if Tool Bar and/or Floating Palettes are open) }
function ActiveWindowNumber: integer; {Window number of active window }
{Get the current window number}
function CurrentWindowNumber: integer; {Window number of current window }
{Get the front most window number}
function FirstWindowNumber: integer; {Window number of front most window }
{ window is open. }
{Get the Tool Bar's window number}
function ToolBarNumber: integer; {Tool Bar's window number }
{Get the first floating Palette's window number}
function FirstPaletteNumber: integer; {Front most floating Palette's window number }
{Get the first standard window's number (not Tool Bar or Floating Palette).}
function FirstStdWindowNumber: integer; {Front most standard window's number }
{Get the working window number}
function WorkWindowNumber: integer; {Working window number }
{Get the window number that contains the active editing field}
function EditFldWindowNumber: integer; {Window number containing active editing field }
{Determine if a window is open}
function WindowIsOpen (Window: integer {Window number }
): boolean; {Is the window open? }
{Determine if a window is visible (open and not hidden)}
function WindowIsVisible (Window: integer {Window number }
): boolean; {Is the window visible? }
{Determine the type of window}
function WindowKind (Window: integer {Window number }
): integer; {Kind of window }
{Get a window's "window pointer" }
function WindowPointer (Window: integer {Window number }
): WindowPtr; {Window's pointer }
{======================================== B U T T O N S ======================================== }
{Create a new button}
procedure NewButton (Button: integer; {Button number }
left, top, right, bottom: integer; {Button's co-ordinates (local) }
Title: string; {Button's title }
procID: integer; {Button's definition ID }
EnabledFlag, SelectedFlag: boolean); {Enable the button? Select the button? }
{Create a new button (co-ordinates specified as a 'rect') }
procedure NewButtonRect (Button: integer; {Button number }
Bounds: rect; {Button's co-ordinates (local) }
Title: string; {Button's title }
procID: integer; {Button's definition ID }
EnabledFlag, SelectedFlag: boolean); {Enable the button? Select the button? }
{Delete a button}
procedure DeleteButton (Button: integer); {Button number }
{Enable/disable a button}
procedure EnableButton (Button: integer; {Button number }
EnabledFlag: boolean); {Enable the button? }
{Select/deselect a button}
procedure SelectButton (Button: integer; {Button number }
SelectedFlag: boolean); {Select the button? }
{Determine if a button is enabled}
function ButtonIsEnabled (Button: integer {Button number }
): boolean; {Is the button enabled? }
{Determine if a button is selected}
function ButtonIsSelected (Button: integer {Button number }
): boolean; {Is the button selected? }
{Set a button's title}
procedure ButtonTitle (Button: integer; {Button number }
Title: string); {Button's title }
{Make a button the window's default button}
procedure SetDefaultButton (Button: integer); {Button number }
{Remove the "default button status" from the window's default button}
procedure NoDefaultButton;
{"Flash" a push button as though it were pressed by the user}
procedure FlashButton (Button: integer); {Button number }
{=================================== P I C T U R E B U T T O N S ================================== }
{Create a new Picture Button}
procedure NewPictButton (Button: integer; {Picture button number }
left, top: integer; {Button's top-left corner in window's local co-ord}
BaseID: integer; {Base image's ID number }
procID: longint; {Appearance and Behavior specifications }
EnabledFlag, SelectedFlag: boolean; {"Button is enabled" & "button is selected" flags }
minimum, value, maximum: integer); {Minimum, current, and maximum value }
{Delete a picture button}
procedure DeletePictButton (Button: integer); {Picture button number }
{Enable/disable a picture button}
procedure EnablePictButton (Button: integer; {Picture button number}
EnabledFlag: boolean); {Enable the picture button? }
{Select/deselect a picture button}
procedure SelectPictButton (Button: integer; {Picture button number }
SelectedFlag: boolean); {Select the picture button? }
{Get a picture button's minimum setting}
function GetPictButtonMin (Button: integer {Picture button number }
): integer; {Picture button's minimum setting }
{Set a picture button's minimum setting}
procedure SetPictButtonMin (Button: integer; {Picture button number }
minimum: integer); {Picture button's minimum setting }
{Get a picture button's maximum setting}
function GetPictButtonMax (Button: integer {Picture button number }
): integer; {Picture button's maximum setting }
{Set a picture button's maximum setting}
procedure SetPictButtonMax (Button: integer; {Picture button number }
maximum: integer); {Picture button's maximum setting }
{Get a picture button's current value}
function GetPictButtonVal (Button: integer {Picture button number }
): integer; {Picture button's current value }
{Set a picture button's current value}
procedure SetPictButtonVal (Button: integer; {Picture button number }
value: integer); {Picture button's value }
{Set a picture button's current value, and simultaneously select/deselect it}
procedure SetPictButtonValSelect (Button: integer; {Picture button number }
value: integer; {Picture button's value }
SelectedFlag: boolean); {Select the picture button? }
{Set a picture button's value acceleration 'automatic value changing' }
procedure SetPictButtonAccel (Button: integer; {Picture button number }
Rate: integer); {0 = Linear, 1-3 = Slow to fast acceleration }
{Set a picture button's speed for 'automatic value changing' }
procedure SetPictButtonSpeed (Button: integer; {Picture button number }
Rate: integer); {Rate of change (value increment per second) }
{Determine if a picture button is enabled}
function PictButtonIsEnabled (Button: integer {Picture button number }
): boolean; {Is the button enabled? }
{Determine if a picture button is selected}
function PictButtonIsSelected (Button: integer {Picture button number }
): boolean; {Is the button selected? }
{"Flash" a picture button as though it were pressed by the user}
procedure FlashPictButton (Button: integer); {Picture button number }
{===================================== S C R O L L B A R S ====================================== }
{Create a new scroll bar}
procedure NewScrollBar (ScrollBar: integer; {Scroll bar number }
left, top, right, bottom: integer; {Scroll bar's co-ordinates (local) }
EnabledFlag: boolean; {Enable the scroll bar? }
minimum, value, maximum: integer); {Minimum, current, and maximum value }
{Create a new scroll bar (co-ordinates specified as a 'rect') }
procedure NewScrollBarRect (ScrollBar: integer; {Scroll bar number }
Bounds: rect; {Scroll bar's co-ordinates (local) }
EnabledFlag: boolean; {Enable the scroll bar? }
minimum, value, maximum: integer); {Minimum, current, and maximum value }
{Delete a scroll bar}
procedure DeleteScrollBar (ScrollBar: integer); {Scroll bar number }
{Enable/disable a scroll bar}
procedure EnableScrollBar (ScrollBar: integer; {Scroll bar number }
EnabledFlag: boolean); {Enable the scroll bar? }
{Get a scroll bar's minimum setting}
function GetScrollBarMin (ScrollBar: integer {Scroll bar number }
): integer; {Scroll bar's minimum setting }
{Set a scroll bar's minimum setting}
procedure SetScrollBarMin (ScrollBar: integer; {Scroll bar number }
minimum: integer); {Scroll bar's minimum setting }
{Get a scroll bar's maximum setting}
function GetScrollBarMax (ScrollBar: integer {Scroll bar number }
): integer; {Scroll bar's maximum setting }
{Set a scroll bar's maximum setting}
procedure SetScrollBarMax (ScrollBar: integer; {Scroll bar number }
maximum: integer); {Scroll bar's maximum setting }
{Get a scroll bar's current value}
function GetScrollBarVal (ScrollBar: integer {Scroll bar number }
): integer; {Scroll bar's current value }
{Set a scroll bar's current value}
procedure SetScrollBarVal (ScrollBar: integer; {Scroll bar number }
value: integer); {Scroll bar's current value }
{==================================== E D I T I N G F I E L D S ==================================== }
{Allocate heap storage for a Pascal string, and initialize it.}
function NewStrHandle (StringLen: integer {Size of string being allocated (1-255 chars) }
): StringHandle; {Handle to allocated string }
{Create a new field}
procedure NewField (Field: integer; {Field number }
left, top, right, bottom: integer; {Field's viewing area co-ordinates (local) }
hStr: Handle; {Handle to edit field's text }
teType: integer; {Type: box around field and/or CR allowed? }
Just: integer); {Justification: left, center, right }
{Create a new field (co-ordinates specified as a 'rect') }
procedure NewFieldRect (Field: integer; {Field number }
Bounds: rect; {Field's viewing area co-ordinates (local) }
hStr: Handle; {Handle to edit field's text }
teType: integer; {Type: box around field and/or CR allowed? }
Just: integer); {Justification: left, center, right }
{Delete a field}
procedure DeleteField (Field: integer); {Field number }
{Activate a field}
procedure ActivateField (Field: integer; {Field number }
Selection: integer); {Text selection: all, start, end }
{Deactivate the active field}
procedure DeactivateField;
{Process a mouse click in an inactive field. The click has been detected by the PollSystem procedure.}
procedure ClickInField;
{Get the active field's edited text}
procedure GetFieldString (var EditString: Str255); {Field's edited text }
{Save the active field's edited text in the field's string}
procedure SaveFieldString;
{Determine the active field number}
function ActiveFieldNumber: integer; {Active field number }
{Determine if a field is empty}
function FieldIsEmpty (Field: integer {Field number }
): boolean; {Is the specified field empty? }
{Turn string length limiting on/off for each new field created starting now}
procedure FieldLengthLimit (Limits: boolean); {Should newly created fields be length-limited? }
{Offset a field}
procedure OffsetField (Field: integer; {Field number }
dh, dv: integer); {Number of pixels to be offset (horiz/vert) }
{Paste text into a field}
procedure PasteIntoField (Field: integer; {Field number }
Text: string; {Text which is to be pasted }
Replace: boolean); {Replace all existing text in field? }
{===================================== L I S T B O X E S ======================================= }
{Create a new List Box}
procedure NewListBox (ListBox: integer; {List box number }
left, top, right, bottom: integer; {List box co-ordinates (local) }
BoxType: SignedByte); {Type of responses to mouse clicks, shift-click, }
{ dragging, etc. }
{Create a new List Box (co-ordinates specified as a 'rect') }
procedure NewListBoxRect (ListBox: integer; {List box number }
Bounds: rect; {List box co-ordinates (local) }
BoxType: SignedByte); {Type of responses to mouse clicks, shift-click, }
{ dragging, etc. }
{Delete a List Box}
procedure DeleteListBox (ListBox: integer); {List box number }
{Set a line of text in a List Box}
procedure SetListBoxText (ListBox: integer; {List box number }
LineNum: integer; {Line number }
Text: string); {Text of specified line number }
{Get a line of text from a List Box}
procedure GetListBoxText (ListBox: integer; {List box number }
LineNum: integer; {Line number }
var Text: Str255); {Text of specified line number }
{Get a List Box's line number whose text is greater than or equal to the specified string}
function SearchListBox (ListBox: integer; {List box number }
Text: string {Text being compared }
): integer; {Line number of text }
{Select/deselect a specified List Box line}
procedure SetListBoxLine (ListBox: integer; {List box number }
LineNum: integer; {Line number }
setIt: boolean); {Selects the line? }
{Determine if a specific List Box line is selected}
function GetListBoxLine (ListBox: integer; {List box number }
LineNum: integer {Line number }
): boolean; {Is the line selected? }
{Get the line number of a selected line in a List Box, starting at LineNum and searching down}
function GetListBoxLines (ListBox: integer; {List box number }
LineNum: integer {Line number }
): integer; {Next selected line }
{Insert a blank line into a List Box}
procedure InsertListBoxLine (ListBox: integer; {List box number }
LineNum: integer); {Line number }
{Delete a line from a List Box}
procedure DeleteListBoxLine (ListBox: integer; {List box number }
LineNum: integer); {Line number }
{Turn a List Box's text drawing on/off}
procedure DrawListBox (ListBox: integer; {List box number }
drawIt: boolean); {Draw the list box's text? }
{========================================= M E N U S ========================================== }
{Create the "Apple" menu}
procedure AppleMenu (AboutName: string); {Optional "About…" name }
{Create a menu name, add/change a menu item, or rename an existing menu item (pull-down & hierarchical menus)}
procedure Menu (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
EnabledFlag: boolean; {Enable the menu? }
MenuText: string); {Menu title or item name }
{Attach a hierarchical menu to a menu item, or detach a hierarchical menu.}
procedure AttachMenu (MenuNumber: integer; {Menu number to which the submenu is attached}
ItemNumber: integer; {Item number to which the submenu is attached }
SubMenuNumber: integer); {Hierarchical menu number being attached }
{Insert a menu item}
procedure InsertMenuitem (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number where insertion is to be made }
EnabledFlag: boolean; {Enable the menu? }
MenuText: string); {Item name }
{Remove an entire menu and its associated items, or a menu item}
procedure RemoveMenu (MenuNumber: integer; {Menu number }
ItemNumber: integer); {Item number within the menu (0=entire menu) }
{Display the menu bar after making changes through the Menu or RemoveMenu procedure}
procedure UpdateMenuBar;
{Get a menu item's text}
procedure GetMenuString (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
var MenuText: Str255); {Menu item's name }
{Change the name of a menu item}
procedure RenameItem (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
MenuText: string); {Menu item's name }
{Enable/disable a menu or menu item}
procedure EnableMenu (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu (or 0) }
EnabledFlag: boolean); {Enable the menu or item? }
{Display/remove a menu item's check mark}
procedure CheckMenu (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
checked: boolean); {Place check mark beside the menu item? }
{Mark a menu item with a specified character (√ or •, etc)}
procedure MenuMark (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
markChar: char); {Menu item's character }
{Get a menu item's ‘mark’ character (√ or •, etc) which is optionally displayed at the item's left side}
procedure GetMenuMark (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
var markChar: char); {Menu item's character }
{Specify a keyboard equivalent for a menu item}
procedure MenuCmd (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
cmdChar: char); {Menu item's keyboard-equivalent character }
{Get a keyboard equivalent for a menu item}
procedure GetMenuCmd (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
var cmdChar: char); {Menu item's keyboard-equivalent character }
{Specify an icon to be displayed by a menu item}
procedure MenuIcon (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
IconSelector: integer); {IconSelector + 256 = cicn or ICON ID }
{Get the specifier for the icon that is displayed by a menu item}
procedure GetMenuIcon (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
var IconSelector: integer); {IconSelector + 256 = cicn or ICON ID }
{Set the character style for a menu item}
procedure MenuStyle (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
theStyle: Style); {Menu item's character style }
{Determine the number of items in a menu}
function MenuItemCount (MenuNumber: integer {Menu number }
): integer; {Number of items in the menu }
{Determine a menu's parent menu number}
procedure GetParentMenu (var MenuNumber: integer; {Parent menu's menu number }
var ItemNumber: integer; {Parent menu's item number }
SubMenuNumber: integer); {Menu number whose parent menu is determined}
{Determine a menu item's submenu number}
procedure GetSubMenu (MenuNumber: integer; {Menu number }
ItemNumber: integer; {Item number within the menu }
var SubMenuNumber: integer); {Menu number of this item's submenu }
{Highlight a menu in the menu bar, or turn off menu bar highlights}
procedure MenuHilite (MenuNumber: integer); {Menu num for a pull-down menu (1-15, 0=none) }
{==================================== P O P - U P M E N U S ===================================== }
{Create a new Pop-Up menu}
procedure NewPopUp (MenuNumber: integer; {Pop-Up Menu number }
left, top, right, bottom: integer; {Enclosing rectangle co-ordinates (local) }
MenuTitle: string; {Title }
procID: integer; {Appearance & Behavior specifications }
EnabledFlag: boolean); {"Menu is enabled" flag }
{Create a new Pop-Up menu (co-ordinates specified as a 'rect') }
procedure NewPopUpRect (MenuNumber: integer; {Pop-Up Menu number }
Bounds: rect; {Enclosing rectangle co-ordinates (local) }
Title: string; {Title }
procID: integer; {Appearance & Behavior specifications }
EnabledFlag: boolean); {"Menu is enabled" flag }
{Add or change a Pop-Up menu item, or rename an existing menu item}
procedure PopUpMenu (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu }
EnabledFlag: boolean; {Enable the menu? }
MenuText: string); {Item name }
{Insert a Pop-Up menu item}
procedure InsertPopUpItem (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number where insertion is to be made }
EnabledFlag: boolean; {Is menu item enabled? }
MenuText: string); {Item name }
{Remove an Pop-Up menu, or a Pop-Up menu item}
procedure RemovePopUp (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer); {Item number within the menu (0=entire menu) }
{Get an Pop-Up Menu item's text}
procedure GetPopUpString (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu }
var MenuText: str255); {Menu item's name }
{Change the name of a Pop-Up Menu item}
procedure RenamePopUp (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu }
MenuText: string); {Menu item's name }
{Enable/disable a Pop-Up Menu or menu item}
procedure EnablePopUp (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu (or 0) }
EnabledFlag: boolean); {Enable the menu or item? }
{Determine if a Pop-Up Menu is enabled}
function PopUpIsEnabled (MenuNumber: integer {Pop-Up Menu number }
): boolean; {Is the menu enabled? }
{Display/remove a Pop-Up Menu item's check mark}
procedure CheckPopUp (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu }
checked: boolean); {Place check mark beside the menu item? }
{Mark a Pop-Up Menu item with a specified character (√ or •, etc)}
procedure PopUpMark (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu }
markChar: char); {Menu item's character }
{Get a Pop-Up Menu item's ‘mark’ character (√ or •, etc) which is optionally displayed at the item's left side}
procedure GetPopUpMark (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu }
var markChar: char); {Menu item's character }
{Specify an icon to be displayed by a Pop-Up Menu item}
procedure PopUpIcon (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu }
IconSelector: integer); {IconSelector + 256 = cicn or ICON ID }
{Get the specifier for the icon that is displayed by a Pop-Up Menu item}
procedure GetPopUpIcon (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu }
var IconSelector: integer); {IconSelector + 256 = cicn or ICON ID }
{Set the character style for a Pop-Up Menu item}
procedure PopUpStyle (MenuNumber: integer; {Pop-Up Menu number }
ItemNumber: integer; {Item number within the menu }
theStyle: Style); {Menu item's character style }
{Determine the number of items in a Pop-Up Menu}
function PopUpItemCount (MenuNumber: integer {Pop-Up Menu number }
): integer; {Number of items in the menu }
{Determine the selected item in a Pop-Up Menu}
function GetPopUpSelection (MenuNumber: integer {Pop-Up Menu number }
): integer; {Selected item in the menu }
{======================================= C U R S O R S ======================================== }
{Change the cursor shape}
procedure CursorShape (CursorType: integer); {Cursor type }
{Reset the cursor to its appropriate shape depending on its location in the active window.}
procedure ResetCursor;
{Create a new Cursor Table}
procedure NewCursorTable (CursorTable: integer; {Cursor table number }
CursorType: integer); {Cursor type }
{Delete a Cursor Table}
procedure DeleteCursorTable (CursorTable: integer); {Cursor table number }
{Add a new Cursor Zone to a Cursor Table, or replace an existing Cursor Zone}
procedure CursorZone (CursorTable: integer; {Cursor table number }
CursorZone: integer; {Cursor zone number }
CursorType: integer; {Cursor type }
left, top, right, bottom: integer); {Cursor zone's co-ordinates (local) }
{Add a new Cursor Zone to a Cursor Table, or replace an existing Cursor Zone (co-ordinates specified as a 'rect') }
procedure CursorZoneRect (CursorTable: integer; {Cursor table number }
CursorZone: integer; {Cursor zone number }
CursorType: integer; {Cursor type }
ZoneRect: rect); {Cursor zone's co-ordinates (local) }
{Add a new Cursor Zone to a Cursor Table, or replace an existing Cursor Zone (co-ordinates specified as a 'region') }
procedure CursorZoneRgn (CursorTable: integer; {Cursor table number }
CursorZone: integer; {Cursor zone number }
CursorType: integer; {Cursor type }
ZoneRgn: RgnHandle); {Cursor zone's region (local) }
{Indicate that the cursor shape may have to be recalculated due to manually altering Cursor Zone regions.}
procedure ChangedCursorZone;
{Delete a Cursor Zone}
procedure DeleteCursorZone (CursorTable: integer; {Cursor table number }
CursorZone: integer); {Cursor zone number }
{Get the bounding rectangle of a specified Cursor Zone}
procedure GetCursorZone (CursorTable: integer; {Cursor table number }
CursorZone: integer; {Cursor zone number }
var ZoneRect: rect); {Cursor zone's bounding rectangle }
{Get a handle to a specified Cursor Zone's region}
function GetCursorZoneRgn (CursorTable: integer; {Cursor table number }
CursorZone: integer {Cursor zone number }
): RgnHandle; {Handle to Cursor zone's region }
{Make the current window use a specified Cursor Table}
procedure UseCursorTable (CursorTable: integer); {Cursor table number }
{Find the cursor zone that contains a specified point}
function FindCursorZone (thePoint: point {Location in window's local co-ordinates }
): integer; {Cursor zone number containing the point }
{Enable/disable clicks on push-buttons when the watchCursor is displayed}
procedure WatchCursorButtons (Allowed: boolean); {Can push-buttons be clicked when the }
{ watchCursor is displayed? }
{======================================== P O L L I N G ========================================= }
{Tools Plus polling procedure}
function PollSystem (var UserPoll: TPPollRecord {Polling record }
): boolean; {Did an event occurred? }
{Set the number of ticks (1/60 sec) your application can wait until it receives a doNothing event.}
procedure SetNullTime (ForegroundTime: longint; {Duration when application is active }
BackgroundTime: longint); {Duration when application is suspended }
{Determine if "waiting for doNothing events" (timed doNothing events) is supported.}
function WaitAvail: boolean; {Is waiting between doNothing events supported?}
{Determine if your application is 'suspended' (i.e. this is not the active application)}
function ApplicationSuspended: boolean; {Is your application suspended? }
{Clear the mouse's current click or drag (i.e. discontinue the process, clear the event}
procedure ResetMouseClicks;
{==================================== C O L O R D R A W I N G =================================== }
{Determine if the Macintosh has Color QuickDraw}
function HasColorQuickDraw: boolean; {Does the Mac have Color QuickDraw? }
{Determine the number of logical screens (distinct screen depth and color/gray settings)}
function NumberOfScreens: integer; {Number of logical screens available }
{Begin updating the specified logical screen}
procedure BeginUpdateScreen (TheScreen: integer); {Logical screen number }
{End updating the most recent logical screen}
procedure EndUpdateScreen;
{Determine the logical screen's depth}
function ScreenDepth: integer; {Screen depth in bits }
{Determine if the logical screen is set to display in color }
function ScreenHasColors: boolean; {Is the screen set to display in color? }
{Color equivalent to 'PenNormal' routine}
procedure PenColorNormal;
{Color equivalent to 'GetPenState' routine}
procedure GetColorPenState (var ThePenState: ColorPenState);
{Color equivalent to 'SetPenState' routine}
procedure SetColorPenState (ThePenState: ColorPenState);
{================================= U S E R N O T I F I C A T I O N ================================= }
{Define the settings for the Notification Manager.}
procedure SetNotification (IconID: integer; {'SICN' icon ID displayed during notification }
SoundID: integer; {Sound ID that is played at notification }
Message: string; {Message displayed during notification }
ResetAfterUse: boolean); {Revert settings to defaults after notification? }
{If this application is inactive, inform user that this application needs attention.}
function PostNotification: boolean; {Was the user notified? }
{==================================== M I S C E L L A N E O U S =================================== }
{Determine the System file version}
function SystemVersion: extended; {System file version (eg: 7.0.1 returned as 7.01)}
{Draw an icon (ICON, ICN#, icl8, icl4, and cicn)}
procedure DrawIcon (theIcon: integer; {Icon ID number }
left, top: integer; {Icon's top-left corner in window's local co-ord. }
EnabledFlag, SelectedFlag: boolean); {Enable the icon? Select the icon? }
{Specify the default appearance for disabled icons}
procedure DefaultIconLook (IconSpec: integer); {Appearance specifications }
{Draw a standard Macintosh progress thermometer}
procedure DrawThermometer (DisplayRect: rect; {Thermometer's co-ordinates (local) }
Percent: real); {Percent complete (i.e. .5 means 50%) }
{Display a dynamic Alert Box and return the use's action}
function AlertBox (theIcon: integer; {Icon ID number }
AlertText: string; {Alert's text }
AlertCode: longint {Button setup codes }
): integer; {Button clicked by user }
{Change a button name for the next use of the dynamic Alert Box}
procedure AlertButtonName (Button: integer; {Button number from 1 to 9 }
Title: string); {Button's title }
{Draw "zoom" lines (expanding/collapsing rectangle)}
procedure ZoomLines (OldRect: Rect; {Starting rectangle (global co-ordinates) }
NewRect: Rect; {Ending rectangle (global co-ordinates) }
Zoom: integer); {Zoom across, in, or out }
{Play the System Error sound}
procedure Beep;
{Wait for a specified duration}
procedure Wait (ClockTicks: longint); {Number of ticks (1/60th sec) to wait }
{Determine the minimum value of 2 numbers}
function min (Val1, Val2: longint): longint;
{Determine the maximum value of 2 numbers}
function max (Val1, Val2: longint): longint;
{PRIVATE: This function obtains the System file's version number as an integer for the SystemVersion function. }
function _SYSV: integer;
implementation
{The SystemVersion function returns the System File's version as an 'extended' type floating-point number. This }
{source code, when compiled, will produce an appropriate 'extended' type floating-point number whose format is }
{determined by your compiler's settings (ie: Compiled for a math co-processor, 68040, or not) }
function SystemVersion;
begin
SystemVersion := _SYSV / 100; {Get System Version and convert to an }
end; { extended type. }
end.
